public class Test {

    //递归求汉诺塔问题
    public static void move(char pos1 ,char pos2) {
        //模拟实现盘子的移动
        //pos1移动到pos2，这里pos1、pos2只是一个代指
        // 比如你想移动A上方的一个盘子到C,你传参就是pos1=A,pos2=B
        System.out.print(pos1+"->"+pos2+" ");
    }

    public static void hanNuoTa(int n,char pos1 ,char pos2,char pos3) {
        //n表示要移动的盘子个数
        //pos1起始位置、pos2中转位置、pos3目标位置
        //因为移动过程中，目标位置、中转位置是会变的
        if(n==1)
        {
            move(pos1,pos3);
        }
        else
        {
            hanNuoTa(n-1,pos1,pos3,pos2);
            //起始位置移动n-1个到中转位置
            move(pos1,pos3);//n-1个移动完，将起始位置最大的1个移动到目标位置
            //问题转换成：pos2是起始位置，pos3目标位置，pos1中转位置，如何将n-1个盘，从pos2移动到pos3
            hanNuoTa(n-1,pos2,pos1,pos3);
        }
    }

    public static void main(String[] args) {
        hanNuoTa(1,'A','B','C');
        System.out.println();
        hanNuoTa(2,'A','B','C');
        System.out.println();
        hanNuoTa(3,'A','B','C');
        System.out.println();
        hanNuoTa(4,'A','B','C');
        System.out.println();
    }

    //在同一个类中定义多个方法：要求不仅可以求2个整数的最大值，还可以求3个小数的最大值？

//    public static int max(int x, int y) {
//        return x>y?x:y;
//    }
//    public static double max(double a, double b, double c) {
//        double max1 = a>b?a:b;
//        return max1>c?max1:c;
//    }
//    public static void main(String[] args) {
//        System.out.println(max(10, 20));
//        System.out.println(max(15.2, 17.8, 15.5));
//    }

    // 在同一个类中,分别定义求两个整数的方法 和 三个小数之和的方法。 并执行代码，求出结果
//    public static int add(int x, int y) {
//        return x+y;
//    }
//
//    public static double add(double a, double b, double c) {
//        return a+b+c;
//    }
//    public static void main(String[] args) {
//        System.out.println(add(10, 20));
//        System.out.println(add(2.5, 2.3, 15.2));
//    }

    //创建方法求两个数的最大值max2，随后再写一个求3个数的最大值的函数max3。
    //要求：在max3这个函数中，调用max2函数，来实现3个数的最大值计算
//    public static int max2(int x, int y) {
//        return x>y?x:y;
//    }
//    public static int max3(int x, int y, int z) {
//        int ret = max2(x, y);
//        int max = max2(ret, z);
//        return max;
//    }
//
//    public static void main(String[] args) {
//        int a = 10;
//        int b = 20;
//        int c = 15;
//        int max = max3(a, b, c);
//        System.out.println(max);
//    }

//    public static void main(String[] args) {
//        int[] array1 = {1,2,3,4};
////        System.out.println(array1[0]);
////        System.out.println(array1[1]);
////        System.out.println(array1[2]);
////        System.out.println(array1[3]);
//        //System.out.println(array1[4]);//数组越界会报错
//        for (int i = 0; i < array1.length; i++) {
//            System.out.println(array1[i]);
//        }
//        //array1.length求数组的长度
//        //foreach循环
//        for (int x:array1) {
//            System.out.println(x);//这种情况拿不到下标
//        }
//    }

//    public static void main(String[] args) {
//        //如果没有对数组初始化 数组元素中有默认值 比如int类型默认值是0
//        char[] array = new char[10];//默认值是/u0000
//        double[] array2 = new double[10];//默认值是0.0
//        boolean[] array3 = new boolean[10];//默认值是false
//        String[] array4 = new String[10];//默认值是null
//    }

    //数组的定义以及初始化
//    public static void main(String[] args) {
        //一组相同类型元素的集合
//        int[] array = {1,2,3,4}; // int[] 是这个数组的类型
//        int[] array1 = new int[10];//定义了一个大小为10个整型的数组 int类型默认初始化为0
//        int[] array2 = new int[]{1,2,3,4,5,6,7,8,9,10};//创建了一个大小是10个整型的数组 里面初始化了1~10  这种情况不用指定数组元素个数
//        //这里可以认为array array1 array2里面存储了数组的为地址
//        System.out.println(array);//array存储了第一个数组的地址 叫做引用变量 也叫引用
//        int array4[] = {1,2,3,4,5,6};//也可以这么写 但不建议
//        //也可以这样定义和初始化
//        int[] array5;
//        array5 = new int[10];
//        int[] array6;
//        array6 = new int[]{1,2,3};
//        //但是不能这样定义和初始化
//        int[] array7;
//        //array7 = {1,2,3,4,5,6,7};//这种必须是在定义的同时进行赋值
//

//    }

    //循环求第N项斐波那契数.
    //第一项从0开始计算
//    public static int fib(int n) {
//        if( n == 1) {
//            return 0;
//        }
//        if (n == 2) {
//            return 1;
//        }
//        int f1 = 0;
//        int f2 = 1;
//        int f3 = -1;
//        for (int i = 3; i <= n; i++) {
//            f3 = f1 + f2;
//            f1 = f2;
//            f2 = f3;
//        }
//        return f3;
//    }
//
//    public static void main(String[] args) {
//        System.out.println(fib(40));
//    }
    //第一项从1开始算起
//    public static int fib(int n) {
//        if( n == 1 || n == 2) {
//            return 1;
//        }
//
//        int f1 = 1;
//        int f2 = 1;
//        int f3 = -1;
//        for (int i = 3; i <= n; i++) {
//            f3 = f1 + f2;
//            f1 = f2;
//            f2 = f3;
//        }
//        return f3;
//    }
//    public static void main(String[] args) {
//        System.out.println(fib(1));
//        System.out.println(fib(2));
//        System.out.println(fib(3));
//        System.out.println(fib(4));
//        System.out.println(fib(40));
//    }


    //递归
    //求斐波那契数列的第N项
    //从0开始算第一项
//    public static int fib(int n) {
//        if(n == 1) {
//            return 0;
//        }
//        if(n == 2) {
//            return 1;
//        }
//        return fib(n-1) + fib(n-2);
//    }
    //第一项从1开始算起
//    public static int fib(int n) {
//        if(n == 1 || n == 2) {
//            return 1;
//        }
//
//        return fib(n-1) + fib(n-2);
//    }
//    public static void main(String[] args) {
//        System.out.println(fib(1));
//        System.out.println(fib(2));
//        System.out.println(fib(3));
//        System.out.println(fib(40));
//
//    }

    //求一个数的每一位加起来的和 比如123 就是 1+2+3 == 6
//    public static int sumP(int n) {
//        if(n < 10) {
//            return n;
//        }
//        return (sumP(n/10)) + (n % 10);
//    }
//    public static void main(String[] args) {
//        int ret = sumP(123);
//        System.out.println(ret);
//    }

    //递归求 1~10的和
//    public static int sum(int n) {
//        if(n == 1) {
//            return 1;
//        }
//        return n + sum(n-1);
//    }
//    public static void main(String[] args) {
//        System.out.println(sum(5));
//    }

    //按顺序打印一个数的每一位

//    public static void print(int n) {
//        if(n > 9) {
//            print(n / 10);
//        }
//        System.out.print((n % 10)+" ");
//    }
//    public static void print(int n) {
//        if(n < 10) {
//            System.out.print(n+" ");
//            return;
//        }
//        print(n / 10);
//        System.out.print((n % 10)+" ");
//    }
//    public static void main(String[] args) {
//        int n = 1234;
//        print(n);
//
//    }

    //递归求n的阶乘
//    public static int fac(int n) {
//        if(n == 1) { //有条件 不然会无休止的递归下去 就会出现栈溢出错误
//            return 1;
//        }
//        return n * fac(n-1);    }
//    public static void main(String[] args) {
//        System.out.println(fac(5));
//    }
//

    //方法重载
    //方法名相同  参数列表不同(数据类型不同 个数不同 顺序不同)
    //返回值不影响重载
//    public static int add(int x, int y) {
//        return x + y;
//    }
//
//    public static int add(int x, int y, int z) {
//        return x + y + z;
//    }
//    public static double add(double x, double y) {
//        return x + y;
//    }
////    public static int add(double x, double y) {
////        return (int)(x + y);
////    }
//    public static void main(String[] args) {
//        int a = 10;
//        int b = 20;
//        System.out.println(add(a ,b));
//        double c = 2.1;
//        double d = 2.3;
//        System.out.println(add(c, d));
//
//    }

    //交换两个临时变量
    //局部变量的作用域是在方法里面 生命周期是调用方法时创建 调用方法结束销毁
    //存储在栈上的 java是不允许拿到局部变量（栈区上的）地址的
    //无返回值的方法不用接收返回值
//    public static void swap(int x, int y) {
//        int tmp = x;
//        x = y;
//        y = tmp;
//        System.out.println("a="+x+" b="+y);
//    }
//    public static void main(String[] args) {
//        int a = 10;
//        int b = 20;
//        System.out.println("a="+a+" b="+b);
//        swap(a, b);
//    }


    //计算1！+2！+3！+4！+5！
//    public static int fac(int n) {
//        int ret = 1;
//        for (int i = 1; i <= n; i++) {
//            ret *= i;
//        }
//        return ret;
//    }
//
//    public static int facSum(int n) {
//        int sum = 0;
//        for (int i = 1; i <= n; i++) {
//            sum += fac(i);
//        }
//        return sum;
//    }
//    public static void main(String[] args) {
//        System.out.println(facSum(5));//传过去的是要计算阶乘和的最大数 比如计算1！~5！的和 这里传过去的实参就是5
//    }


    //计算n的阶乘
//    public static int fac(int n) {
//        int ret = 1;
//        for (int i = 1; i <= n; i++) {
//            ret *= i;
//        }
//        return ret;
//    }
//
//    public static void main(String[] args) {
//        int ret = fac(5);
//        System.out.println(ret);
//        System.out.println(fac(4));
//    }


    //判断整数相加
//    public static int add(int x, int y) {
//        return x + y;
//    }
//    public static void main(String[] args) {
//        int a = 10;
//        int b = 20;
//        int sum = add(a, b);
//        int sum2 = add(200, 100);//方法可以调用多次
//        System.out.println(sum);
//        System.out.println(sum2);
//    }

    //判断是否为闰年
//    public static boolean isLeapYear(int year) {
//        if(((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
//            return true;
//        } else {
//            return false;
//        }
//    }
//
//    public static void main(String[] args) {
//        //判断是否为闰年
//        int year = 2000;
//        boolean fla = isLeapYear(year);
//        System.out.println(fla);
//    }
}
